home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / site-packages / impacket / dcerpc / svcctl.py < prev    next >
Encoding:
Python Source  |  2006-05-23  |  16.0 KB  |  515 lines
  1. # Copyright (c) 2003-2006 CORE Security Technologies
  2. #
  3. # This software is provided under under a slightly modified version
  4. # of the Apache Software License. See the accompanying LICENSE file
  5. # for more information.
  6. #
  7. # $Id: svcctl.py,v 1.6 2006/05/23 21:19:26 gera Exp $
  8. #
  9. # Description:
  10. #   SVCCTL (Services Control) interface implementation.
  11. #
  12.  
  13. import array
  14. from struct import *
  15.  
  16. from impacket import ImpactPacket
  17. import dcerpc
  18.  
  19. MSRPC_UUID_SVCCTL = '\x81\xbb\x7a\x36\x44\x98\xf1\x35\xad\x32\x98\xf0\x38\x00\x10\x03\x02\x00\x00\x00'
  20.  
  21. class SVCCTLOpenSCManagerHeader(ImpactPacket.Header):
  22.     OP_NUM = 0x1B
  23.  
  24.     __SIZE = 32
  25.  
  26.     def __init__(self, aBuffer = None):
  27.         ImpactPacket.Header.__init__(self, SVCCTLOpenSCManagerHeader.__SIZE)
  28.  
  29.         self.set_referent_id(0xFFFFFF)
  30.         self.set_access_mask(0xF003F)
  31.  
  32.         if aBuffer: self.load_header(aBuffer)
  33.  
  34.     def get_referent_id(self):
  35.         return self.get_long(0, '<')
  36.     def set_referent_id(self, id):
  37.         self.set_long(0, id, '<')
  38.  
  39.     def get_max_count(self):
  40.         return self.get_long(4, '<')
  41.     def set_max_count(self, num):
  42.         self.set_long(4, num, '<')
  43.  
  44.     def get_offset(self):
  45.         return self.get_long(8, '<')
  46.     def set_offset(self, num):
  47.         self.set_long(8, num, '<')
  48.  
  49.     def get_cur_count(self):
  50.         return self.get_long(12, '<')
  51.     def set_cur_count(self, num):
  52.         self.set_long(12, num, '<')
  53.  
  54.     def get_machine_name(self):
  55.         return self.get_bytes().tostring()[:20]
  56.     def set_machine_name(self, name):
  57.         assert len(name) <= 8
  58.         self.set_max_count(len(name) + 1)
  59.         self.set_cur_count(len(name) + 1)
  60.         self.get_bytes()[16:24] = array.array('B', name + (8 - len(name)) * '\x00')
  61.  
  62.     def get_access_mask(self):
  63.         return self.get_long(28, '<')
  64.     def set_access_mask(self, mask):
  65.         self.set_long(28, mask, '<')
  66.  
  67.  
  68.     def get_header_size(self):
  69.         return SVCCTLOpenSCManagerHeader.__SIZE
  70.  
  71.  
  72. class SVCCTLRespOpenSCManagerHeader(ImpactPacket.Header):
  73.     __SIZE = 24
  74.  
  75.     def __init__(self, aBuffer = None):
  76.         ImpactPacket.Header.__init__(self, SVCCTLRespOpenSCManagerHeader.__SIZE)
  77.         if aBuffer: self.load_header(aBuffer)
  78.  
  79.     def get_context_handle(self):
  80.         return self.get_bytes().tolist()[:20]
  81.     def set_context_handle(self, handle):
  82.         assert 20 == len(handle)
  83.         self.get_bytes()[:20] = array.array('B', handle)
  84.  
  85.     def get_return_code(self):
  86.         return self.get_long(20, '<')
  87.     def set_return_code(self, code):
  88.         self.set_long(20, code, '<')
  89.  
  90.  
  91.     def get_header_size(self):
  92.         return SVCCTLRespOpenSCManagerHeader.__SIZE
  93.  
  94.  
  95. class SVCCTLOpenServiceHeader(ImpactPacket.Header):
  96.     OP_NUM = 0x1C
  97.  
  98.     __SIZE = 48
  99.  
  100.  
  101.     def __init__(self, aBuffer = None):
  102.         ImpactPacket.Header.__init__(self, SVCCTLOpenServiceHeader.__SIZE)
  103.  
  104.         self.set_max_count(9)
  105.         self.set_cur_count(9)
  106.         # Write some unknown fluff.
  107.         self.get_bytes()[40:] = array.array('B', '\x00\x10\x48\x60\xff\x01\x0f\x00')
  108.  
  109.         if aBuffer: self.load_header(aBuffer)
  110.  
  111.     def get_context_handle(self):
  112.         return self.get_bytes().tolist()[:20]
  113.     def set_context_handle(self, handle):
  114.         assert 20 == len(handle)
  115.         self.get_bytes()[:20] = array.array('B', handle)
  116.  
  117.     def get_max_count(self):
  118.         return self.get_long(20, '<')
  119.     def set_max_count(self, num):
  120.         self.set_long(20, num, '<')
  121.  
  122.     def get_offset(self):
  123.         return self.get_long(24, '<')
  124.     def set_offset(self, num):
  125.         self.set_long(24, num, '<')
  126.  
  127.     def get_cur_count(self):
  128.         return self.get_long(28, '<')
  129.     def set_cur_count(self, num):
  130.         self.set_long(28, num, '<')
  131.  
  132.     def get_service_name(self):
  133.         return self.get_bytes().tostring()[32:40]
  134.     def set_service_name(self, name):
  135.         assert len(name) <= 8
  136.         self.get_bytes()[32:40] = array.array('B', name + (8 - len(name)) * '\x00')
  137.  
  138.  
  139.     def get_header_size(self):
  140.         return SVCCTLOpenServiceHeader.__SIZE
  141.  
  142.  
  143. class SVCCTLRespOpenServiceHeader(ImpactPacket.Header):
  144.     __SIZE = 24
  145.  
  146.     def __init__(self, aBuffer = None):
  147.         ImpactPacket.Header.__init__(self, SVCCTLRespOpenServiceHeader.__SIZE)
  148.         if aBuffer: self.load_header(aBuffer)
  149.  
  150.     def get_context_handle(self):
  151.         return self.get_bytes().tolist()[:20]
  152.     def set_context_handle(self, handle):
  153.         assert 20 == len(handle)
  154.         self.get_bytes()[:20] = array.array('B', handle)
  155.  
  156.     def get_return_code(self):
  157.         return self.get_long(20, '<')
  158.     def set_return_code(self, code):
  159.         self.set_long(20, code, '<')
  160.  
  161.  
  162.     def get_header_size(self):
  163.         return SVCCTLRespOpenServiceHeader.__SIZE
  164.  
  165.  
  166. class SVCCTLCloseServiceHeader(ImpactPacket.Header):
  167.     OP_NUM = 0x0
  168.  
  169.     __SIZE = 20
  170.  
  171.     def __init__(self, aBuffer = None):
  172.         ImpactPacket.Header.__init__(self, SVCCTLCloseServiceHeader.__SIZE)
  173.         if aBuffer: self.load_header(aBuffer)
  174.  
  175.     def get_context_handle(self):
  176.         return self.get_bytes().tolist()[:]
  177.     def set_context_handle(self, handle):
  178.         assert 20 == len(handle)
  179.         self.get_bytes()[:] = array.array('B', handle)
  180.  
  181.  
  182.     def get_header_size(self):
  183.         return SVCCTLCloseServiceHeader.__SIZE
  184.  
  185.  
  186. class SVCCTLRespCloseServiceHeader(ImpactPacket.Header):
  187.     __SIZE = 24
  188.  
  189.     def __init__(self, aBuffer = None):
  190.         ImpactPacket.Header.__init__(self, SVCCTLRespCloseServiceHeader.__SIZE)
  191.         if aBuffer: self.load_header(aBuffer)
  192.  
  193.     def get_context_handle(self):
  194.         return self.get_bytes().tolist()[:20]
  195.     def set_context_handle(self, handle):
  196.         assert 20 == len(handle)
  197.         self.get_bytes()[:20] = array.array('B', handle)
  198.  
  199.     def get_return_code(self):
  200.         return self.get_long(20, '<')
  201.     def set_return_code(self, code):
  202.         self.set_long(20, code, '<')
  203.  
  204.  
  205.     def get_header_size(self):
  206.         return SVCCTLRespCloseServiceHeader.__SIZE
  207.  
  208.  
  209. class SVCCTLCreateServiceHeader(ImpactPacket.Header):
  210.     OP_NUM = 0x18
  211.  
  212.     __SIZE = 132
  213.  
  214.     def __init__(self, aBuffer = None):
  215.         ImpactPacket.Header.__init__(self, SVCCTLCreateServiceHeader.__SIZE)
  216.  
  217.         self.set_name_max_count(9)
  218.         self.set_name_cur_count(9)
  219.         self.set_service_flags(0x110)
  220.         self.set_start_mode(2)
  221.         self.get_bytes()[40:48] = array.array('B', '\x00\x10\x48\x60\xe4\xa3\x40\x00')
  222.         self.get_bytes()[68:76] = array.array('B', '\x00\x00\x00\x00\xff\x01\x0f\x00')
  223.         self.get_bytes()[84:88] = array.array('B', '\x01\x00\x00\x00')
  224.  
  225.         if aBuffer: self.load_header(aBuffer)
  226.  
  227.     def get_context_handle(self):
  228.         return self.get_bytes().tolist()[:20]
  229.     def set_context_handle(self, handle):
  230.         assert 20 == len(handle)
  231.         self.get_bytes()[:20] = array.array('B', handle)
  232.  
  233.     def get_name_max_count(self):
  234.         return self.get_long(4, '<')
  235.     def set_name_max_count(self, num):
  236.         self.set_long(20, num, '<')
  237.         self.set_long(48, num, '<')
  238.  
  239.     def get_name_offset(self):
  240.         return self.get_long(8, '<')
  241.     def set_name_offset(self, num):
  242.         self.set_long(24, num, '<')
  243.         self.set_long(52, num, '<')
  244.  
  245.     def get_name_cur_count(self):
  246.         return self.get_long(12, '<')
  247.     def set_name_cur_count(self, num):
  248.         self.set_long(28, num, '<')
  249.         self.set_long(56, num, '<')
  250.  
  251.     def get_service_name(self):
  252.         return self.get_bytes().tostring()[32:40]
  253.     def set_service_name(self, name):
  254.         self.get_bytes()[32:40] = array.array('B', name + (8 - len(name)) * '\x00')
  255.         self.get_bytes()[60:68] = array.array('B', name + (8 - len(name)) * '\x00')
  256.  
  257.     # 0x0000100 = Allow service to interact with desktop (needed by vnc server for example)
  258.     # 0x0000010 = Log as: Local System Account
  259.     def get_service_flags(self):
  260.         return self.get_long(76, '<')
  261.     def set_service_flags(self, flags):
  262.         self.set_long(76, flags, '<')
  263.  
  264.     # 2 Automatic
  265.     # 3 Manual
  266.     # 4 Disabled
  267.     def get_start_mode(self):
  268.         return self.get_long(80, '<')
  269.     def set_start_mode(self, mode):
  270.         self.set_long(80, mode, '<')
  271.  
  272.     def get_path_max_count(self):
  273.         return self.get_long(88, '<')
  274.     def set_path_max_count(self, num):
  275.         self.set_long(88, num, '<')
  276.  
  277.     def get_path_offset(self):
  278.         return self.get_long(92, '<')
  279.     def set_path_offset(self, num):
  280.         self.set_long(92, num, '<')
  281.  
  282.     def get_path_cur_count(self):
  283.         return self.get_long(96, '<')
  284.     def set_path_cur_count(self, num):
  285.         self.set_long(96, num, '<')
  286.  
  287.     def get_service_path(self):
  288.         return self.get_bytes().tostring()[100:-32]
  289.     def set_service_path(self, path):
  290.         self.get_bytes()[100:-32] = array.array('B', path)
  291.         self.set_path_max_count(len(path)+1)
  292.         self.set_path_cur_count(len(path)+1)
  293.  
  294.  
  295.     def get_header_size(self):
  296.         var_size = len(self.get_bytes()) - SVCCTLCreateServiceHeader.__SIZE
  297.         assert var_size > 0
  298.         return SVCCTLCreateServiceHeader.__SIZE + var_size
  299.  
  300.  
  301. class SVCCTLRespCreateServiceHeader(ImpactPacket.Header):
  302.     __SIZE = 28
  303.  
  304.     def __init__(self, aBuffer = None):
  305.         ImpactPacket.Header.__init__(self, SVCCTLRespCreateServiceHeader.__SIZE)
  306.         if aBuffer: self.load_header(aBuffer)
  307.  
  308.     def get_context_handle(self):
  309.         return self.get_bytes().tolist()[4:24]
  310.     def set_context_handle(self, handle):
  311.         assert 20 == len(handle)
  312.         self.get_bytes()[4:24] = array.array('B', handle)
  313.  
  314.     def get_return_code(self):
  315.         return self.get_long(24, '<')
  316.     def set_return_code(self, code):
  317.         self.set_long(24, code, '<')
  318.  
  319.  
  320.     def get_header_size(self):
  321.         return SVCCTLRespCreateServiceHeader.__SIZE
  322.  
  323.  
  324. class SVCCTLDeleteServiceHeader(ImpactPacket.Header):
  325.     OP_NUM = 0x2
  326.  
  327.     __SIZE = 20
  328.  
  329.     def __init__(self, aBuffer = None):
  330.         ImpactPacket.Header.__init__(self, SVCCTLDeleteServiceHeader.__SIZE)
  331.         if aBuffer: self.load_header(aBuffer)
  332.  
  333.     def get_context_handle(self):
  334.         return self.get_bytes().tolist()[:20]
  335.     def set_context_handle(self, handle):
  336.         assert 20 == len(handle)
  337.         self.get_bytes()[:20] = array.array('B', handle)
  338.  
  339.  
  340.     def get_header_size(self):
  341.         return SVCCTLDeleteServiceHeader.__SIZE
  342.  
  343.  
  344. class SVCCTLRespDeleteServiceHeader(dcerpc.MSRPCHeader):
  345.     __SIZE = 4
  346.  
  347.     def __init__(self, aBuffer = None):
  348.         ImpactPacket.Header.__init__(self, SVCCTLRespDeleteServiceHeader.__SIZE)
  349.         if aBuffer: self.load_header(aBuffer)
  350.  
  351.     def get_return_code(self):
  352.         return self.get_long(0, '<')
  353.     def set_return_code(self, code):
  354.         self.set_long(0, code, '<')
  355.  
  356.  
  357.     def get_header_size(self):
  358.         return SVCCTLRespDeleteServiceHeader.__SIZE
  359.  
  360.  
  361. class SVCCTLStopServiceHeader(ImpactPacket.Header):
  362.     OP_NUM = 0x1
  363.  
  364.     __SIZE = 24
  365.  
  366.     def __init__(self, aBuffer = None):
  367.         ImpactPacket.Header.__init__(self, SVCCTLStopServiceHeader.__SIZE)
  368.  
  369.         # Write some unknown fluff.
  370.         self.get_bytes()[20:] = array.array('B', '\x01\x00\x00\x00')
  371.  
  372.         if aBuffer: self.load_header(aBuffer)
  373.  
  374.     def get_context_handle(self):
  375.         return self.get_bytes().tolist()[:20]
  376.     def set_context_handle(self, handle):
  377.         assert 20 == len(handle)
  378.         self.get_bytes()[:20] = array.array('B', handle)
  379.  
  380.  
  381.     def get_header_size(self):
  382.         return SVCCTLStopServiceHeader.__SIZE
  383.  
  384.  
  385. class SVCCTLRespStopServiceHeader(ImpactPacket.Header):
  386.     __SIZE = 32
  387.  
  388.     def __init__(self, aBuffer = None):
  389.         ImpactPacket.Header.__init__(self, SVCCTLRespStopServiceHeader.__SIZE)
  390.         if aBuffer: self.load_header(aBuffer)
  391.  
  392.     def get_return_code(self):
  393.         return self.get_long(28, '<')
  394.     def set_return_code(self, code):
  395.         self.set_long(28, code, '<')
  396.  
  397.  
  398.     def get_header_size(self):
  399.         return SVCCTLRespStopServiceHeader.__SIZE
  400.  
  401.  
  402. class SVCCTLStartServiceHeader(ImpactPacket.Header):
  403.     OP_NUM = 0x1F
  404.  
  405.     __SIZE = 32
  406.  
  407.     def __init__(self, aBuffer = None):
  408.         ImpactPacket.Header.__init__(self, SVCCTLStartServiceHeader.__SIZE)
  409.         if aBuffer: self.load_header(aBuffer)
  410.  
  411.     def get_context_handle(self):
  412.         return self.get_bytes().tolist()[:20]
  413.     def set_context_handle(self, handle):
  414.         assert 20 == len(handle)
  415.         self.get_bytes()[:20] = array.array('B', handle)
  416.  
  417.     def get_arguments(self):
  418.         raise Exception, "method not implemented"
  419.     def set_arguments(self, arguments):
  420.         args_data = apply(pack, ['<' + 'L'*len(arguments)] + map(id, arguments) )
  421.         args_data += reduce(lambda a, b: a+b,
  422.                             map(lambda element: pack('<LLL', len(element)+1, 0, len(element)+1) + element + '\x00' + '\x00' * ((4 - (len(element) + 1) % 4) % 4), arguments),
  423.                             '')
  424.         data = pack('<LLL', len(arguments), id(arguments), len(arguments)) + args_data
  425.         self.get_bytes()[20:] = array.array('B', data)
  426.  
  427.  
  428.     def get_header_size(self):
  429.         var_size = len(self.get_bytes()) - SVCCTLStartServiceHeader.__SIZE
  430.         assert var_size > 0
  431.         return SVCCTLStartServiceHeader.__SIZE + var_size
  432.  
  433.  
  434. class SVCCTLRespStartServiceHeader(ImpactPacket.Header):
  435.     __SIZE = 4
  436.  
  437.     def __init__(self, aBuffer = None):
  438.         ImpactPacket.Header.__init__(self, SVCCTLRespStartServiceHeader.__SIZE)
  439.         if aBuffer: self.load_header(aBuffer)
  440.  
  441.     def get_return_code(self):
  442.         return self.get_long(0, '<')
  443.     def set_return_code(self, code):
  444.         self.set_long(0, code, '<')
  445.  
  446.  
  447.     def get_header_size(self):
  448.         return SVCCTLRespStartServiceHeader.__SIZE
  449.  
  450.  
  451. class DCERPCSvcCtl:
  452.     def __init__(self, dcerpc):
  453.         self._dcerpc = dcerpc
  454.  
  455.     def open_manager(self):
  456.         hostname = 'IMPACT'
  457.         opensc = SVCCTLOpenSCManagerHeader()
  458.         opensc.set_machine_name(hostname)
  459.         self._dcerpc.send(opensc)
  460.         data = self._dcerpc.recv()
  461.         retVal = SVCCTLRespOpenSCManagerHeader(data)
  462.         return retVal
  463.  
  464.     def create_service(self, context_handle, service_name, service_path):
  465.         creates = SVCCTLCreateServiceHeader()
  466.         creates.set_context_handle(context_handle)
  467.         creates.set_service_name(service_name)
  468.         creates.set_service_path(service_path)
  469.         self._dcerpc.send(creates)
  470.         data = self._dcerpc.recv()
  471.         retVal = SVCCTLRespCreateServiceHeader(data)
  472.         return retVal
  473.  
  474.     def close_handle(self, context_handle):
  475.         closeh = SVCCTLCloseServiceHeader()
  476.         closeh.set_context_handle(context_handle)
  477.         self._dcerpc.send(closeh)
  478.         data = self._dcerpc.recv()
  479.         retVal = SVCCTLRespCloseServiceHeader(data)
  480.         return retVal
  481.  
  482.     def delete_service(self, context_handle):
  483.         deletes = SVCCTLDeleteServiceHeader()
  484.         deletes.set_context_handle(context_handle)
  485.         self._dcerpc.send(deletes)
  486.         data = self._dcerpc.recv()
  487.         retVal = SVCCTLRespDeleteServiceHeader(data)
  488.         return retVal
  489.  
  490.     def open_service(self, context_handle, service_name):
  491.         opens = SVCCTLOpenServiceHeader()
  492.         opens.set_context_handle(context_handle)
  493.         opens.set_service_name(service_name)
  494.         self._dcerpc.send(opens)
  495.         data = self._dcerpc.recv()
  496.         retVal = SVCCTLRespOpenServiceHeader(data)
  497.         return retVal
  498.  
  499.     def stop_service(self, context_handle):
  500.         stops = SVCCTLStopServiceHeader()
  501.         stops.set_context_handle(context_handle)
  502.         self._dcerpc.send(stops)
  503.         data = self._dcerpc.recv()
  504.         retVal = SVCCTLRespStopServiceHeader(data)
  505.         return retVal
  506.  
  507.     def start_service(self, context_handle, arguments):
  508.         starts = SVCCTLStartServiceHeader()
  509.         starts.set_arguments( arguments )
  510.         starts.set_context_handle(context_handle)
  511.         self._dcerpc.send(starts)
  512.         data = self._dcerpc.recv()
  513.         retVal = SVCCTLRespStartServiceHeader(data)
  514.         return retVal
  515.